Cream of the Crop 21/Cream of the Crop 21 (Terry Blount) (October 1996).iso/doom/dme4bt13.zip/CONCEPTS.TXT

Text File | 1994-10-01 | 24KB | 498 lines

                              Important concepts
                              ------------------

The first thing any map maker needs to know is the terminalogy used to
describe everything.  So, here goes:

Map:

   A map is all the information that describes a single episode/mission.
Many people like to use the word 'level' instead, however I think that
'map' is a better word to use.  I tend to use 'level' to mean the
difficulty level the player selects when playing doom.

Vertexes:

   A vertex is a point in 2D space.  Therefore, a vertex is really an
ordered pair of map coordinates.  Vertexes appear as dots in DMapEdit
(if they are shown).

Note: Of all the choices of words to use (vertex, point, node, etc) id
software decided to use vertex, and I just decided to follow along with
their terminalogy.  They also call the plural of vertex 'vertexes', and
not 'vertices'.  So, I also used this.

Lines:

   Lines are straight line segments from one vertex to another.  Lines
themselves don't have any ordered pair information, and so since
vertexes do, all lines must run between 2 vertexes.  Lines are used for
walls in Doom, but they can also be used for other things, as explained
later in this file.

Linedefs:

   A linedef is short for 'line definition', and is the information that
describes a line.  Basically, lines and linedefs are the same thing.

Sidedefs:

   All lines have 2 sides to them, a left and a right side.  To
understand this, keep in mind that even though DMapEdit shows a line as
2 dimentional, it is really a vertical plane (no z-axis tilt).  (This
plane doesn't have any thinkness to it, by the way.)  When you are
playing Doom, you can see these planes as walls.  Of course, you only
see one side of this plane at a time.  The other side can't be seen
because the first side blocks your vision of it.  These are the 2 sides
of the line I am talking about.

Ok, so which side is the left and which is the right?  Well, remember that
lines start at vertex A and end at vertex B.  If you think of yourself as
standing on vertex A and look straight at vertex B, then the 2 sides
face out to your left and to your right.  The left one is the left
side, and the right one is the right side.

Now, a sidedef (side definition) describes a side of a line.  A line
may, however, only have 1 sidedef.  If so, then this line is called
single-sided.  It actually does have 2 sides, of course, but the second
side isn't defined (no sidedef).  So, here we see a distinction between
a side and a sidedef.  All lines have 2 sides, but either 0, 1, or 2
sidedefs.  A line with no sidedefs is possible, and will usually occur
during map making, however it should never appear in a finished map.
Doing so will confuse Doom and cause strange things to happen.

Sectors:

   A sector is a closed polygon area of the map, formed by the lines.  A
sector definition describes the characteristics of this area, including
the floor and ceiling altitudes, floor and ceiling textures (see below),
lighting, etc.  Any time you want any one of these characteristics to
change, you need to create a new sector for it (to hold the new def)

Interestingly enough, the area of a sector is completely determined by
lines and sidedefs.  But, we'll get into that a little later..

Closed polygon:

   A closed polygon is a shape formed with 3 or more lines connected to
that each vertex has at least 2 lines jointed there.  Also, starting at
any one vertex, you can follow a path of lines, following each one only
once, and arrive back at that vertex again.  That's the technical
description; basically it is an object, such as a triangle, square,
trapazoid, or any other possible configuration of lines.  If it's still
unclear, there little illustration will hopefully clear it up:


   +----+      +          +----+         +    +      +   +          +
   |    |     / \        /    /          |    |     /     \        /
   |    |    /   \      /    /           |    |    /       \      /
   |    |   /     \    /    /            |    |   /         \    /
   +----+  +-------+  +----+             +----+  +------+    +--+

   Closed polygons, legal sectors        Open polygons, illegel sectors

A term I often use for open polygons is 'line dead-end error'.  This is
from the fact that if you are tracing along the lines, you will hit a
dead end sooner or later.  Close polygons will allow you to trace along
the lines forever, around and around..

Things:

   Things are all objects in the game, such as barrels, dead bodies,
guns, ammo, players, monsters, player starting points, etc.  Walls, doors,
elevators, windows, etc are not Things, but rather lines and sectors.
All Things should lie within sectors, and not be stuck in a solid wall.

Blockmap:

   This is an internal structure that Doom uses to detect wall
collisions.  Once you make a new map, a blockmap must be generated
before it can be used with Doom.  DMapEdit itself doesn't use this
structure for anything, so you only need to worry about making it right
before you play the map.

Nodes:

   This is another internal structure (a Binary Space Partition tree) used
by Doom to figure out which walls are behind which, so it can skip
drawing certain walls and be the fast game we all love.  I don't really
know how it uses it for this purpose, but it does.  Because I don't know
this, though, DMapEdit doesn't use it in any way, just like the
blockmap.  So, don't bother making nodes until when you make the blockmap.

Segments:

   A segment is simply a whole line or a piece of a line.  Segments are
tightly related with nodes, and created when nodes are created.  Node
generatation is automatic, and so you will probably never need to know
about segments.

Sub Sectors:

   Another internal structure tightly related with nodes.  It describes
a piece of a sector, in the shape of a convex polygon (less then or equal
to 180 degrees bend between all lines, measured on the inside angle of the
polygon).

Texture:

   A texture is an image that is projected onto a plane surface, just
like a slide projecter projects an image on a screen.  So why is it
called a texture then?  Because that's what id calls it, and I'm going
along with their terms.  The use of the word texture goes back before
that, though.  I guess because before texture-mapping, walls looked flat
and boring.  When an image is projected on that wall, though, it can
seem to have a lot of texture to it then.  So, it's actually a visual
texture, and not a surface texture.

PWAD:

   A PWAD (also known as a 'working wad file'), is a collection of data
files all combined into one file, with extention WAD.  The file DOOM.WAD
is an IWAD file, however.  Both are WADs.  IWAD probably stands for
Initial WAD, while PWAD stands for Patched WAD.  The first 4 bytes of a
WAD file will be IWAD or PWAD, thus identifying it's WAD type.  Basically,
when you play doom with a PWAD file, it will try to get any data it need
from the PWAD, and if it can't find something, it will load it from the
IWAD instead.  DMapEdit only saves out PWADs, since only id software has
the right to use an IWAD header for a WAD.

E1M1:

   This is just map notation for the episode and mission numbers.
(episode 1, mission 1 in this case).  This happens to be the way a
header looks in the wad file, and is just an abbriviation, really.  I
will often call this the 'map position'.

Object:

   An object is a Thing, Vertex, Line, Sidedef, or Sector.  Objects are
the building blocks the user has to make maps with.

---

To build maps properly, a map maker needs to understand how the various
map elements work and inter-relate.

Objects can be broken up into 2 groups: Things and non-Things.  This is
because all non-things tend to inter-relate with each other, while
Things don't inter-relate to anything.  This gives Things a certain
advantage.  Things can be edited completely independently of non-Things.
If you are in